// $ANTLR 3.4 D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g 2012-10-21 12:08:20
package antlr.output;

import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

import org.antlr.runtime.tree.*;


@SuppressWarnings({"all", "warnings", "unchecked"})
public class MultiFarParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "AMP_BEGIN", "AMP_END", "BOLD", "COLON", "COMA", "COMMENT", "DOT", "DOT3", "END", "LABEL", "LETTER", "L_BRACKET", "L_PARENTHESIS", "L_TRIANGULAR", "NO_COMMA", "NO_DOT", "NUMERATION", "ROMB", "R_BRACKET", "R_PARENTHESIS", "R_TRIANGULAR", "SEE", "SEMI", "TILDA", "WORD", "WS"
    };

    public static final int EOF=-1;
    public static final int AMP_BEGIN=4;
    public static final int AMP_END=5;
    public static final int BOLD=6;
    public static final int COLON=7;
    public static final int COMA=8;
    public static final int COMMENT=9;
    public static final int DOT=10;
    public static final int DOT3=11;
    public static final int END=12;
    public static final int LABEL=13;
    public static final int LETTER=14;
    public static final int L_BRACKET=15;
    public static final int L_PARENTHESIS=16;
    public static final int L_TRIANGULAR=17;
    public static final int NO_COMMA=18;
    public static final int NO_DOT=19;
    public static final int NUMERATION=20;
    public static final int ROMB=21;
    public static final int R_BRACKET=22;
    public static final int R_PARENTHESIS=23;
    public static final int R_TRIANGULAR=24;
    public static final int SEE=25;
    public static final int SEMI=26;
    public static final int TILDA=27;
    public static final int WORD=28;
    public static final int WS=29;

    // delegates
    public Parser[] getDelegates() {
        return new Parser[] {};
    }

    // delegators


    public MultiFarParser(TokenStream input) {
        this(input, new RecognizerSharedState());
    }
    public MultiFarParser(TokenStream input, RecognizerSharedState state) {
        super(input, state);
    }

protected TreeAdaptor adaptor = new CommonTreeAdaptor();

public void setTreeAdaptor(TreeAdaptor adaptor) {
    this.adaptor = adaptor;
}
public TreeAdaptor getTreeAdaptor() {
    return adaptor;
}
    public String[] getTokenNames() { return MultiFarParser.tokenNames; }
    public String getGrammarFileName() { return "D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g"; }


      @Override
      public void reportError(RecognitionException e) {
        System.out.println("I quit from parser!");
        throw new RuntimeException(e.getMessage()); 
      }


    public static class prog_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "prog"
    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:27:1: prog : ( entry )+ ;
    public final MultiFarParser.prog_return prog() throws RecognitionException {
        MultiFarParser.prog_return retval = new MultiFarParser.prog_return();
        retval.start = input.LT(1);


        CommonTree root_0 = null;

        MultiFarParser.entry_return entry1 =null;



        try {
            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:27:9: ( ( entry )+ )
            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:27:11: ( entry )+
            {
            root_0 = (CommonTree)adaptor.nil();


            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:27:11: ( entry )+
            int cnt1=0;
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( (LA1_0==BOLD||LA1_0==COMMENT||(LA1_0 >= DOT3 && LA1_0 <= LETTER)||LA1_0==NO_COMMA||(LA1_0 >= NUMERATION && LA1_0 <= ROMB)||LA1_0==WORD) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:27:12: entry
            	    {
            	    pushFollow(FOLLOW_entry_in_prog68);
            	    entry1=entry();

            	    state._fsp--;

            	    adaptor.addChild(root_0, entry1.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt1 >= 1 ) break loop1;
                        EarlyExitException eee =
                            new EarlyExitException(1, input);
                        throw eee;
                }
                cnt1++;
            } while (true);


            }

            retval.stop = input.LT(-1);


            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "prog"


    public static class entry_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "entry"
    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:29:1: entry : ( classifire )? ( numeratedItems | combination | farTranslations | example )+ ;
    public final MultiFarParser.entry_return entry() throws RecognitionException {
        MultiFarParser.entry_return retval = new MultiFarParser.entry_return();
        retval.start = input.LT(1);


        CommonTree root_0 = null;

        MultiFarParser.classifire_return classifire2 =null;

        MultiFarParser.numeratedItems_return numeratedItems3 =null;

        MultiFarParser.combination_return combination4 =null;

        MultiFarParser.farTranslations_return farTranslations5 =null;

        MultiFarParser.example_return example6 =null;



        try {
            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:30:3: ( ( classifire )? ( numeratedItems | combination | farTranslations | example )+ )
            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:30:3: ( classifire )? ( numeratedItems | combination | farTranslations | example )+
            {
            root_0 = (CommonTree)adaptor.nil();


            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:30:3: ( classifire )?
            int alt2=2;
            int LA2_0 = input.LA(1);

            if ( ((LA2_0 >= END && LA2_0 <= LABEL)) ) {
                alt2=1;
            }
            switch (alt2) {
                case 1 :
                    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:30:3: classifire
                    {
                    pushFollow(FOLLOW_classifire_in_entry81);
                    classifire2=classifire();

                    state._fsp--;

                    adaptor.addChild(root_0, classifire2.getTree());

                    }
                    break;

            }


            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:30:15: ( numeratedItems | combination | farTranslations | example )+
            int cnt3=0;
            loop3:
            do {
                int alt3=5;
                switch ( input.LA(1) ) {
                case END:
                case LABEL:
                    {
                    alt3=3;
                    }
                    break;
                case NUMERATION:
                    {
                    alt3=1;
                    }
                    break;
                case ROMB:
                    {
                    alt3=2;
                    }
                    break;
                case COMMENT:
                case DOT3:
                case LETTER:
                case NO_COMMA:
                case WORD:
                    {
                    alt3=3;
                    }
                    break;
                case BOLD:
                    {
                    alt3=4;
                    }
                    break;

                }

                switch (alt3) {
            	case 1 :
            	    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:30:16: numeratedItems
            	    {
            	    pushFollow(FOLLOW_numeratedItems_in_entry85);
            	    numeratedItems3=numeratedItems();

            	    state._fsp--;

            	    adaptor.addChild(root_0, numeratedItems3.getTree());

            	    }
            	    break;
            	case 2 :
            	    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:30:33: combination
            	    {
            	    pushFollow(FOLLOW_combination_in_entry89);
            	    combination4=combination();

            	    state._fsp--;

            	    adaptor.addChild(root_0, combination4.getTree());

            	    }
            	    break;
            	case 3 :
            	    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:30:47: farTranslations
            	    {
            	    pushFollow(FOLLOW_farTranslations_in_entry93);
            	    farTranslations5=farTranslations();

            	    state._fsp--;

            	    adaptor.addChild(root_0, farTranslations5.getTree());

            	    }
            	    break;
            	case 4 :
            	    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:30:63: example
            	    {
            	    pushFollow(FOLLOW_example_in_entry95);
            	    example6=example();

            	    state._fsp--;

            	    adaptor.addChild(root_0, example6.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt3 >= 1 ) break loop3;
                        EarlyExitException eee =
                            new EarlyExitException(3, input);
                        throw eee;
                }
                cnt3++;
            } while (true);


            }

            retval.stop = input.LT(-1);


            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "entry"


    public static class classifire_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "classifire"
    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:32:1: classifire : ( LABEL | END )+ ;
    public final MultiFarParser.classifire_return classifire() throws RecognitionException {
        MultiFarParser.classifire_return retval = new MultiFarParser.classifire_return();
        retval.start = input.LT(1);


        CommonTree root_0 = null;

        Token set7=null;

        CommonTree set7_tree=null;

        try {
            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:33:2: ( ( LABEL | END )+ )
            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:33:4: ( LABEL | END )+
            {
            root_0 = (CommonTree)adaptor.nil();


            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:33:4: ( LABEL | END )+
            int cnt4=0;
            loop4:
            do {
                int alt4=2;
                int LA4_0 = input.LA(1);

                if ( ((LA4_0 >= END && LA4_0 <= LABEL)) ) {
                    alt4=1;
                }


                switch (alt4) {
            	case 1 :
            	    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:
            	    {
            	    set7=(Token)input.LT(1);

            	    if ( (input.LA(1) >= END && input.LA(1) <= LABEL) ) {
            	        input.consume();
            	        adaptor.addChild(root_0, 
            	        (CommonTree)adaptor.create(set7)
            	        );
            	        state.errorRecovery=false;
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    if ( cnt4 >= 1 ) break loop4;
                        EarlyExitException eee =
                            new EarlyExitException(4, input);
                        throw eee;
                }
                cnt4++;
            } while (true);


            }

            retval.stop = input.LT(-1);


            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "classifire"


    public static class combination_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "combination"
    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:35:1: combination : ROMB ( example )+ ;
    public final MultiFarParser.combination_return combination() throws RecognitionException {
        MultiFarParser.combination_return retval = new MultiFarParser.combination_return();
        retval.start = input.LT(1);


        CommonTree root_0 = null;

        Token ROMB8=null;
        MultiFarParser.example_return example9 =null;


        CommonTree ROMB8_tree=null;

        try {
            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:36:2: ( ROMB ( example )+ )
            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:36:4: ROMB ( example )+
            {
            root_0 = (CommonTree)adaptor.nil();


            ROMB8=(Token)match(input,ROMB,FOLLOW_ROMB_in_combination121); 
            ROMB8_tree = 
            (CommonTree)adaptor.create(ROMB8)
            ;
            adaptor.addChild(root_0, ROMB8_tree);


            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:36:9: ( example )+
            int cnt5=0;
            loop5:
            do {
                int alt5=2;
                alt5 = dfa5.predict(input);
                switch (alt5) {
            	case 1 :
            	    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:36:10: example
            	    {
            	    pushFollow(FOLLOW_example_in_combination124);
            	    example9=example();

            	    state._fsp--;

            	    adaptor.addChild(root_0, example9.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt5 >= 1 ) break loop5;
                        EarlyExitException eee =
                            new EarlyExitException(5, input);
                        throw eee;
                }
                cnt5++;
            } while (true);


            }

            retval.stop = input.LT(-1);


            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "combination"


    public static class numeratedItems_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "numeratedItems"
    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:38:1: numeratedItems : NUMERATION ( example | farTranslations )+ ;
    public final MultiFarParser.numeratedItems_return numeratedItems() throws RecognitionException {
        MultiFarParser.numeratedItems_return retval = new MultiFarParser.numeratedItems_return();
        retval.start = input.LT(1);


        CommonTree root_0 = null;

        Token NUMERATION10=null;
        MultiFarParser.example_return example11 =null;

        MultiFarParser.farTranslations_return farTranslations12 =null;


        CommonTree NUMERATION10_tree=null;

        try {
            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:39:2: ( NUMERATION ( example | farTranslations )+ )
            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:39:4: NUMERATION ( example | farTranslations )+
            {
            root_0 = (CommonTree)adaptor.nil();


            NUMERATION10=(Token)match(input,NUMERATION,FOLLOW_NUMERATION_in_numeratedItems136); 
            NUMERATION10_tree = 
            (CommonTree)adaptor.create(NUMERATION10)
            ;
            adaptor.addChild(root_0, NUMERATION10_tree);


            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:39:15: ( example | farTranslations )+
            int cnt6=0;
            loop6:
            do {
                int alt6=3;
                alt6 = dfa6.predict(input);
                switch (alt6) {
            	case 1 :
            	    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:39:16: example
            	    {
            	    pushFollow(FOLLOW_example_in_numeratedItems139);
            	    example11=example();

            	    state._fsp--;

            	    adaptor.addChild(root_0, example11.getTree());

            	    }
            	    break;
            	case 2 :
            	    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:39:26: farTranslations
            	    {
            	    pushFollow(FOLLOW_farTranslations_in_numeratedItems143);
            	    farTranslations12=farTranslations();

            	    state._fsp--;

            	    adaptor.addChild(root_0, farTranslations12.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt6 >= 1 ) break loop6;
                        EarlyExitException eee =
                            new EarlyExitException(6, input);
                        throw eee;
                }
                cnt6++;
            } while (true);


            }

            retval.stop = input.LT(-1);


            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "numeratedItems"


    public static class example_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "example"
    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:41:1: example : BOLD ( farTranslations )+ ;
    public final MultiFarParser.example_return example() throws RecognitionException {
        MultiFarParser.example_return retval = new MultiFarParser.example_return();
        retval.start = input.LT(1);


        CommonTree root_0 = null;

        Token BOLD13=null;
        MultiFarParser.farTranslations_return farTranslations14 =null;


        CommonTree BOLD13_tree=null;

        try {
            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:42:3: ( BOLD ( farTranslations )+ )
            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:42:3: BOLD ( farTranslations )+
            {
            root_0 = (CommonTree)adaptor.nil();


            BOLD13=(Token)match(input,BOLD,FOLLOW_BOLD_in_example155); 
            BOLD13_tree = 
            (CommonTree)adaptor.create(BOLD13)
            ;
            adaptor.addChild(root_0, BOLD13_tree);


            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:42:8: ( farTranslations )+
            int cnt7=0;
            loop7:
            do {
                int alt7=2;
                alt7 = dfa7.predict(input);
                switch (alt7) {
            	case 1 :
            	    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:42:9: farTranslations
            	    {
            	    pushFollow(FOLLOW_farTranslations_in_example158);
            	    farTranslations14=farTranslations();

            	    state._fsp--;

            	    adaptor.addChild(root_0, farTranslations14.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt7 >= 1 ) break loop7;
                        EarlyExitException eee =
                            new EarlyExitException(7, input);
                        throw eee;
                }
                cnt7++;
            } while (true);


            }

            retval.stop = input.LT(-1);


            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "example"


    public static class farTranslations_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "farTranslations"
    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:44:1: farTranslations : ( nearTranslationUnits SEMI )+ ;
    public final MultiFarParser.farTranslations_return farTranslations() throws RecognitionException {
        MultiFarParser.farTranslations_return retval = new MultiFarParser.farTranslations_return();
        retval.start = input.LT(1);


        CommonTree root_0 = null;

        Token SEMI16=null;
        MultiFarParser.nearTranslationUnits_return nearTranslationUnits15 =null;


        CommonTree SEMI16_tree=null;

        try {
            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:45:2: ( ( nearTranslationUnits SEMI )+ )
            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:45:4: ( nearTranslationUnits SEMI )+
            {
            root_0 = (CommonTree)adaptor.nil();


            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:45:4: ( nearTranslationUnits SEMI )+
            int cnt8=0;
            loop8:
            do {
                int alt8=2;
                int LA8_0 = input.LA(1);

                if ( ((LA8_0 >= END && LA8_0 <= LABEL)) ) {
                    alt8=1;
                }
                else if ( (LA8_0==COMMENT||LA8_0==DOT3||LA8_0==LETTER||LA8_0==NO_COMMA||LA8_0==WORD) ) {
                    alt8=1;
                }


                switch (alt8) {
            	case 1 :
            	    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:45:5: nearTranslationUnits SEMI
            	    {
            	    pushFollow(FOLLOW_nearTranslationUnits_in_farTranslations171);
            	    nearTranslationUnits15=nearTranslationUnits();

            	    state._fsp--;

            	    adaptor.addChild(root_0, nearTranslationUnits15.getTree());

            	    SEMI16=(Token)match(input,SEMI,FOLLOW_SEMI_in_farTranslations173); 
            	    SEMI16_tree = 
            	    (CommonTree)adaptor.create(SEMI16)
            	    ;
            	    adaptor.addChild(root_0, SEMI16_tree);


            	    }
            	    break;

            	default :
            	    if ( cnt8 >= 1 ) break loop8;
                        EarlyExitException eee =
                            new EarlyExitException(8, input);
                        throw eee;
                }
                cnt8++;
            } while (true);


            }

            retval.stop = input.LT(-1);


            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "farTranslations"


    public static class nearTranslationUnits_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "nearTranslationUnits"
    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:47:1: nearTranslationUnits : translationUnit ( COMA translationUnit )* ;
    public final MultiFarParser.nearTranslationUnits_return nearTranslationUnits() throws RecognitionException {
        MultiFarParser.nearTranslationUnits_return retval = new MultiFarParser.nearTranslationUnits_return();
        retval.start = input.LT(1);


        CommonTree root_0 = null;

        Token COMA18=null;
        MultiFarParser.translationUnit_return translationUnit17 =null;

        MultiFarParser.translationUnit_return translationUnit19 =null;


        CommonTree COMA18_tree=null;

        try {
            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:48:2: ( translationUnit ( COMA translationUnit )* )
            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:48:4: translationUnit ( COMA translationUnit )*
            {
            root_0 = (CommonTree)adaptor.nil();


            pushFollow(FOLLOW_translationUnit_in_nearTranslationUnits187);
            translationUnit17=translationUnit();

            state._fsp--;

            adaptor.addChild(root_0, translationUnit17.getTree());

            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:48:20: ( COMA translationUnit )*
            loop9:
            do {
                int alt9=2;
                int LA9_0 = input.LA(1);

                if ( (LA9_0==COMA) ) {
                    alt9=1;
                }


                switch (alt9) {
            	case 1 :
            	    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:48:21: COMA translationUnit
            	    {
            	    COMA18=(Token)match(input,COMA,FOLLOW_COMA_in_nearTranslationUnits190); 
            	    COMA18_tree = 
            	    (CommonTree)adaptor.create(COMA18)
            	    ;
            	    adaptor.addChild(root_0, COMA18_tree);


            	    pushFollow(FOLLOW_translationUnit_in_nearTranslationUnits192);
            	    translationUnit19=translationUnit();

            	    state._fsp--;

            	    adaptor.addChild(root_0, translationUnit19.getTree());

            	    }
            	    break;

            	default :
            	    break loop9;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "nearTranslationUnits"


    public static class translationUnit_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "translationUnit"
    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:50:1: translationUnit : ( WORD | LETTER | LABEL | COMMENT | NO_COMMA | DOT3 | END )+ ;
    public final MultiFarParser.translationUnit_return translationUnit() throws RecognitionException {
        MultiFarParser.translationUnit_return retval = new MultiFarParser.translationUnit_return();
        retval.start = input.LT(1);


        CommonTree root_0 = null;

        Token set20=null;

        CommonTree set20_tree=null;

        try {
            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:51:2: ( ( WORD | LETTER | LABEL | COMMENT | NO_COMMA | DOT3 | END )+ )
            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:51:4: ( WORD | LETTER | LABEL | COMMENT | NO_COMMA | DOT3 | END )+
            {
            root_0 = (CommonTree)adaptor.nil();


            // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:51:4: ( WORD | LETTER | LABEL | COMMENT | NO_COMMA | DOT3 | END )+
            int cnt10=0;
            loop10:
            do {
                int alt10=2;
                int LA10_0 = input.LA(1);

                if ( (LA10_0==COMMENT||(LA10_0 >= DOT3 && LA10_0 <= LETTER)||LA10_0==NO_COMMA||LA10_0==WORD) ) {
                    alt10=1;
                }


                switch (alt10) {
            	case 1 :
            	    // D:\\Projects\\oop-example\\src\\antlr\\MultiFar.g:
            	    {
            	    set20=(Token)input.LT(1);

            	    if ( input.LA(1)==COMMENT||(input.LA(1) >= DOT3 && input.LA(1) <= LETTER)||input.LA(1)==NO_COMMA||input.LA(1)==WORD ) {
            	        input.consume();
            	        adaptor.addChild(root_0, 
            	        (CommonTree)adaptor.create(set20)
            	        );
            	        state.errorRecovery=false;
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    if ( cnt10 >= 1 ) break loop10;
                        EarlyExitException eee =
                            new EarlyExitException(10, input);
                        throw eee;
                }
                cnt10++;
            } while (true);


            }

            retval.stop = input.LT(-1);


            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "translationUnit"

    // Delegated rules


    protected DFA5 dfa5 = new DFA5(this);
    protected DFA6 dfa6 = new DFA6(this);
    protected DFA7 dfa7 = new DFA7(this);
    static final String DFA5_eotS =
        "\7\uffff";
    static final String DFA5_eofS =
        "\1\1\6\uffff";
    static final String DFA5_minS =
        "\1\6\1\uffff\1\11\1\10\1\11\1\uffff\1\10";
    static final String DFA5_maxS =
        "\1\34\1\uffff\3\34\1\uffff\1\34";
    static final String DFA5_acceptS =
        "\1\uffff\1\2\3\uffff\1\1\1\uffff";
    static final String DFA5_specialS =
        "\7\uffff}>";
    static final String[] DFA5_transitionS = {
            "\1\2\2\uffff\1\1\1\uffff\4\1\3\uffff\1\1\1\uffff\2\1\6\uffff"+
            "\1\1",
            "",
            "\1\3\1\uffff\4\3\3\uffff\1\3\11\uffff\1\3",
            "\1\4\1\3\1\uffff\4\3\3\uffff\1\3\7\uffff\1\5\1\uffff\1\3",
            "\1\6\1\uffff\4\6\3\uffff\1\6\11\uffff\1\6",
            "",
            "\1\4\1\6\1\uffff\4\6\3\uffff\1\6\7\uffff\1\5\1\uffff\1\6"
    };

    static final short[] DFA5_eot = DFA.unpackEncodedString(DFA5_eotS);
    static final short[] DFA5_eof = DFA.unpackEncodedString(DFA5_eofS);
    static final char[] DFA5_min = DFA.unpackEncodedStringToUnsignedChars(DFA5_minS);
    static final char[] DFA5_max = DFA.unpackEncodedStringToUnsignedChars(DFA5_maxS);
    static final short[] DFA5_accept = DFA.unpackEncodedString(DFA5_acceptS);
    static final short[] DFA5_special = DFA.unpackEncodedString(DFA5_specialS);
    static final short[][] DFA5_transition;

    static {
        int numStates = DFA5_transitionS.length;
        DFA5_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA5_transition[i] = DFA.unpackEncodedString(DFA5_transitionS[i]);
        }
    }

    class DFA5 extends DFA {

        public DFA5(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 5;
            this.eot = DFA5_eot;
            this.eof = DFA5_eof;
            this.min = DFA5_min;
            this.max = DFA5_max;
            this.accept = DFA5_accept;
            this.special = DFA5_special;
            this.transition = DFA5_transition;
        }
        public String getDescription() {
            return "()+ loopback of 36:9: ( example )+";
        }
    }
    static final String DFA6_eotS =
        "\14\uffff";
    static final String DFA6_eofS =
        "\1\1\13\uffff";
    static final String DFA6_minS =
        "\1\6\1\uffff\1\6\1\10\2\11\1\uffff\2\10\1\11\1\uffff\1\10";
    static final String DFA6_maxS =
        "\1\34\1\uffff\4\34\1\uffff\3\34\1\uffff\1\34";
    static final String DFA6_acceptS =
        "\1\uffff\1\3\4\uffff\1\2\3\uffff\1\1\1\uffff";
    static final String DFA6_specialS =
        "\14\uffff}>";
    static final String[] DFA6_transitionS = {
            "\1\4\2\uffff\1\3\1\uffff\1\3\2\2\1\3\3\uffff\1\3\1\uffff\2\1"+
            "\6\uffff\1\3",
            "",
            "\1\1\1\uffff\1\5\1\3\1\uffff\1\3\2\2\1\3\3\uffff\1\3\1\uffff"+
            "\2\1\4\uffff\1\6\1\uffff\1\3",
            "\1\5\1\3\1\uffff\4\3\3\uffff\1\3\7\uffff\1\6\1\uffff\1\3",
            "\1\7\1\uffff\4\7\3\uffff\1\7\11\uffff\1\7",
            "\1\10\1\uffff\4\10\3\uffff\1\10\11\uffff\1\10",
            "",
            "\1\11\1\7\1\uffff\4\7\3\uffff\1\7\7\uffff\1\12\1\uffff\1\7",
            "\1\5\1\10\1\uffff\4\10\3\uffff\1\10\7\uffff\1\6\1\uffff\1\10",
            "\1\13\1\uffff\4\13\3\uffff\1\13\11\uffff\1\13",
            "",
            "\1\11\1\13\1\uffff\4\13\3\uffff\1\13\7\uffff\1\12\1\uffff\1"+
            "\13"
    };

    static final short[] DFA6_eot = DFA.unpackEncodedString(DFA6_eotS);
    static final short[] DFA6_eof = DFA.unpackEncodedString(DFA6_eofS);
    static final char[] DFA6_min = DFA.unpackEncodedStringToUnsignedChars(DFA6_minS);
    static final char[] DFA6_max = DFA.unpackEncodedStringToUnsignedChars(DFA6_maxS);
    static final short[] DFA6_accept = DFA.unpackEncodedString(DFA6_acceptS);
    static final short[] DFA6_special = DFA.unpackEncodedString(DFA6_specialS);
    static final short[][] DFA6_transition;

    static {
        int numStates = DFA6_transitionS.length;
        DFA6_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA6_transition[i] = DFA.unpackEncodedString(DFA6_transitionS[i]);
        }
    }

    class DFA6 extends DFA {

        public DFA6(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 6;
            this.eot = DFA6_eot;
            this.eof = DFA6_eof;
            this.min = DFA6_min;
            this.max = DFA6_max;
            this.accept = DFA6_accept;
            this.special = DFA6_special;
            this.transition = DFA6_transition;
        }
        public String getDescription() {
            return "()+ loopback of 39:15: ( example | farTranslations )+";
        }
    }
    static final String DFA7_eotS =
        "\7\uffff";
    static final String DFA7_eofS =
        "\1\1\6\uffff";
    static final String DFA7_minS =
        "\1\6\1\uffff\1\6\1\10\1\11\1\uffff\1\10";
    static final String DFA7_maxS =
        "\1\34\1\uffff\3\34\1\uffff\1\34";
    static final String DFA7_acceptS =
        "\1\uffff\1\2\3\uffff\1\1\1\uffff";
    static final String DFA7_specialS =
        "\7\uffff}>";
    static final String[] DFA7_transitionS = {
            "\1\1\2\uffff\1\3\1\uffff\1\3\2\2\1\3\3\uffff\1\3\1\uffff\2\1"+
            "\6\uffff\1\3",
            "",
            "\1\1\1\uffff\1\4\1\3\1\uffff\1\3\2\2\1\3\3\uffff\1\3\1\uffff"+
            "\2\1\4\uffff\1\5\1\uffff\1\3",
            "\1\4\1\3\1\uffff\4\3\3\uffff\1\3\7\uffff\1\5\1\uffff\1\3",
            "\1\6\1\uffff\4\6\3\uffff\1\6\11\uffff\1\6",
            "",
            "\1\4\1\6\1\uffff\4\6\3\uffff\1\6\7\uffff\1\5\1\uffff\1\6"
    };

    static final short[] DFA7_eot = DFA.unpackEncodedString(DFA7_eotS);
    static final short[] DFA7_eof = DFA.unpackEncodedString(DFA7_eofS);
    static final char[] DFA7_min = DFA.unpackEncodedStringToUnsignedChars(DFA7_minS);
    static final char[] DFA7_max = DFA.unpackEncodedStringToUnsignedChars(DFA7_maxS);
    static final short[] DFA7_accept = DFA.unpackEncodedString(DFA7_acceptS);
    static final short[] DFA7_special = DFA.unpackEncodedString(DFA7_specialS);
    static final short[][] DFA7_transition;

    static {
        int numStates = DFA7_transitionS.length;
        DFA7_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA7_transition[i] = DFA.unpackEncodedString(DFA7_transitionS[i]);
        }
    }

    class DFA7 extends DFA {

        public DFA7(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 7;
            this.eot = DFA7_eot;
            this.eof = DFA7_eof;
            this.min = DFA7_min;
            this.max = DFA7_max;
            this.accept = DFA7_accept;
            this.special = DFA7_special;
            this.transition = DFA7_transition;
        }
        public String getDescription() {
            return "()+ loopback of 42:8: ( farTranslations )+";
        }
    }
 

    public static final BitSet FOLLOW_entry_in_prog68 = new BitSet(new long[]{0x0000000010347A42L});
    public static final BitSet FOLLOW_classifire_in_entry81 = new BitSet(new long[]{0x0000000010347A40L});
    public static final BitSet FOLLOW_numeratedItems_in_entry85 = new BitSet(new long[]{0x0000000010347A42L});
    public static final BitSet FOLLOW_combination_in_entry89 = new BitSet(new long[]{0x0000000010347A42L});
    public static final BitSet FOLLOW_farTranslations_in_entry93 = new BitSet(new long[]{0x0000000010347A42L});
    public static final BitSet FOLLOW_example_in_entry95 = new BitSet(new long[]{0x0000000010347A42L});
    public static final BitSet FOLLOW_ROMB_in_combination121 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_example_in_combination124 = new BitSet(new long[]{0x0000000000000042L});
    public static final BitSet FOLLOW_NUMERATION_in_numeratedItems136 = new BitSet(new long[]{0x0000000010047A40L});
    public static final BitSet FOLLOW_example_in_numeratedItems139 = new BitSet(new long[]{0x0000000010047A42L});
    public static final BitSet FOLLOW_farTranslations_in_numeratedItems143 = new BitSet(new long[]{0x0000000010047A42L});
    public static final BitSet FOLLOW_BOLD_in_example155 = new BitSet(new long[]{0x0000000010047A00L});
    public static final BitSet FOLLOW_farTranslations_in_example158 = new BitSet(new long[]{0x0000000010047A02L});
    public static final BitSet FOLLOW_nearTranslationUnits_in_farTranslations171 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_SEMI_in_farTranslations173 = new BitSet(new long[]{0x0000000010047A02L});
    public static final BitSet FOLLOW_translationUnit_in_nearTranslationUnits187 = new BitSet(new long[]{0x0000000000000102L});
    public static final BitSet FOLLOW_COMA_in_nearTranslationUnits190 = new BitSet(new long[]{0x0000000010047A00L});
    public static final BitSet FOLLOW_translationUnit_in_nearTranslationUnits192 = new BitSet(new long[]{0x0000000000000102L});

}